home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / sdi / menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-18  |  3.9 KB  |  201 lines
  1. #include <suntool/sunview.h>
  2. #include <stdio.h>
  3. #include "walkmenu_impl.h"
  4. #include "image_impl.h"
  5.  
  6. #define MAX_ITEMS 32
  7.  
  8. /*
  9.  * Copyright 1987 by Mark Weiser.
  10.  * Permission to reproduce and use in any manner whatsoever on Suns is granted
  11.  * so long as this copyright and other identifying marks of authorship
  12.  * in the code and the game remain intact and visible.  Use of this code
  13.  * in other products is reserved to me--I'm working on Mac and IBM versions.
  14.  */
  15.  
  16. /*
  17.  * Pie menu code -- patent applied for.
  18.  */
  19.  
  20. /*
  21.  * The front-end routines to make pie-menus look like the normal
  22.  * Sun window library (at least a little bit).
  23.  */
  24.  
  25.  
  26. void
  27. pie_menu_set(m, arg)
  28. struct menu *m;
  29. int arg;
  30. {
  31.     char **argptr = &(char *)arg;
  32.     pie_menu_set_internal(m, argptr);
  33. }
  34.  
  35. pie_menu_item_set(mi, arg)
  36. struct menu_item *mi;
  37. int arg;
  38. {
  39.     char **argptr = &(char *)arg;
  40.     pie_menu_item_set_internal(mi, argptr);
  41. }
  42.  
  43. struct menu *
  44. pie_menu_create(arg)
  45. int arg;
  46. {
  47.     char **argptr = &(char *)arg;
  48.     struct menu *m;
  49.     m = (struct menu *)calloc(sizeof(struct menu),1);
  50.     m->item_list = (struct menu_item **)calloc(sizeof(struct menu_item *), MAX_ITEMS);
  51.     m->max_nitems = MAX_ITEMS;
  52.     pie_menu_set_internal(m, argptr);
  53.     return m;
  54. }
  55.  
  56. struct menu_item *
  57. pie_menu_create_item(arg)
  58. int arg;
  59. {
  60.     char **argptr = &(char *)arg;
  61.     struct menu_item *mi;
  62.     mi = (struct menu_item *)calloc(sizeof(struct menu_item),1);
  63.     mi->image = (struct image *)calloc(sizeof(struct image),1);
  64.     pie_menu_item_set_internal(mi, argptr);
  65.     return mi;
  66. }
  67.  
  68. pie_menu_set_internal(m, argptr)
  69. struct menu *m;
  70. char **argptr;
  71. {
  72.     while (*argptr != 0) {
  73.         switch(*argptr) {
  74.             case MENU_APPEND_ITEM: {
  75.                 if (m->nitems >= (m->max_nitems-1))
  76.                     {
  77.                     fprintf("Too many items in a pie menu.\n");
  78.                     abort();
  79.                 }
  80.                 m->item_list[m->nitems] = (struct menu_item *)(*(argptr+1));
  81.                 ((struct menu_item *)m->item_list[m->nitems])->parent = m;
  82.                 m->nitems += 1;
  83.                 argptr += 2; break;
  84.             }
  85.             case MENU_NOTIFY_PROC: {
  86.                 (caddr_t)m->notify_proc = (caddr_t)(*(argptr+1));
  87.                 argptr += 2; break;
  88.             }
  89.             default: {
  90.                 fprintf(stderr, "Unexpected item in pie_menu_set_internal.\n");
  91.                 abort();
  92.                 break;
  93.             }
  94.         }
  95.     }
  96. }
  97.  
  98. pie_menu_item_set_internal(mi, argptr)
  99. struct menu_item *mi;
  100. char **argptr;
  101. {
  102.     while (*argptr != 0) {
  103.         switch(*argptr) {
  104.             case MENU_IMAGE:  {
  105.                 mi->image->pr = (struct pixrect *)*(argptr+1);
  106.                 argptr += 2; break;
  107.             }
  108.             case MENU_STRING: {
  109.                 mi->image->string = (char *)*(argptr+1);
  110.                 argptr += 2; break;
  111.             }
  112.             case MENU_PULLRIGHT: {
  113.                 mi->pullright = TRUE;
  114.                 mi->value = (caddr_t)*(argptr+1);
  115.                 ((struct menu *)mi->value)->parent = mi;
  116.                 argptr += 2; break;
  117.             }
  118.             case MENU_RELEASE: {
  119.                 mi->free_item = TRUE;
  120.                 argptr += 1; break;
  121.             }
  122.             case MENU_RELEASE_IMAGE: {
  123.                 mi->image->free_image = TRUE;
  124.                 argptr += 1; break;
  125.             }
  126.             case MENU_CLIENT_DATA: {
  127.                 mi->client_data = (caddr_t)*(argptr+1);
  128.                 argptr += 2; break;
  129.             }
  130.             default: {
  131.                 fprintf(stderr, "Unexpected item in pie_menu_item_set_internal.\n");
  132.                 abort();
  133.                 break;
  134.             }
  135.         }
  136.     }
  137. }
  138.  
  139. pie_menu_destroy(m)
  140. struct menu *m;
  141. {
  142.     int i;
  143.     if (m == NULL) return;
  144.     for (i=0; i<m->nitems; i++) {
  145.         if (m->item_list[i]->free_item) {
  146.             free(m->item_list[i]->image);
  147.             free(m->item_list[i]);
  148.         }
  149.     }
  150.     free(m->item_list);
  151.     free(m);
  152. }
  153.  
  154. caddr_t
  155. pie_menu_get(m, arg)
  156. struct menu *m;
  157. Menu_attribute arg;
  158. {
  159.     switch(arg) {
  160.         case MENU_CLIENT_DATA: {
  161.             return (caddr_t) m->client_data;
  162.             break;
  163.         }
  164.         default: {
  165.             fprintf(stderr, "Unexpected item in pie_menu_get.\n");
  166.             abort();
  167.             break;
  168.         }
  169.     }
  170. }
  171.  
  172. caddr_t
  173. pie_menu_item_get(mi, arg)
  174. struct menu_item *mi;
  175. Menu_attribute arg;
  176. {
  177.     switch(arg) {
  178.         case MENU_CLIENT_DATA: {
  179.             return (caddr_t) mi->client_data;
  180.             break;
  181.         }
  182.         default: {
  183.             fprintf(stderr, "Unexpected item in pie_menu_item_get.\n");
  184.             abort();
  185.             break;
  186.         }
  187.     }
  188. }
  189.  
  190. caddr_t
  191. pie_menu_show(m, w, e, f, s)
  192. struct menu *m;
  193. Window w;
  194. Event *e;
  195. int (*f)();
  196. char *s;
  197. {
  198.     struct menu_item *rval;
  199.     rval = (struct menu_item *)menu_track(m, w, e, f, s);
  200. }
  201.